{
 "cells": [
  {
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-11-20T11:12:13.603844Z",
     "start_time": "2025-11-20T11:12:13.599976Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "# 一、1. 创建 3x3 的随机矩阵 A（元素范围 [0, 1)）\n",
    "A = np.random.rand(3, 3)\n",
    "print(\"0-1之间的随机矩阵：\")\n",
    "print(A)\n"
   ],
   "id": "initial_id",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0-1之间的随机矩阵：\n",
      "[[0.24433243 0.78778043 0.60236144]\n",
      " [0.12448977 0.98189079 0.77429465]\n",
      " [0.82970867 0.43030763 0.0618154 ]]\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T11:30:11.831389Z",
     "start_time": "2025-11-20T11:30:11.828480Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 2. 创建 3x3 的单位矩阵 I\n",
    "I = np.eye(3)\n",
    "print(\"单位矩阵 I：\")\n",
    "print(I)\n"
   ],
   "id": "4bbd191f82bc3960",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "单位矩阵 I：\n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "execution_count": 23
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T11:15:41.755541Z",
     "start_time": "2025-11-20T11:15:41.721810Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 3. 计算各种运算\n",
    "# A + I\n",
    "add_result = A + I\n",
    "print(\"A + I（矩阵加法）：\")\n",
    "print(add_result)\n",
    "print()\n",
    "\n",
    "# A * I\n",
    "element_wise_multiply = A * I\n",
    "print(\"A * I（逐元素乘法）：\")\n",
    "print(element_wise_multiply)\n",
    "print()\n",
    "\n",
    "# 矩阵乘法 A @ I\n",
    "matrix_multiply = A @ I\n",
    "print(\"A @ I（矩阵乘法）：\")\n",
    "print(matrix_multiply)\n",
    "print()"
   ],
   "id": "ed6de1c91040261",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A + I（矩阵加法）：\n",
      "[[1.24433243 0.78778043 0.60236144]\n",
      " [0.12448977 1.98189079 0.77429465]\n",
      " [0.82970867 0.43030763 1.0618154 ]]\n",
      "\n",
      "A * I（逐元素乘法）：\n",
      "[[0.24433243 0.         0.        ]\n",
      " [0.         0.98189079 0.        ]\n",
      " [0.         0.         0.0618154 ]]\n",
      "\n",
      "A @ I（矩阵乘法）：\n",
      "[[0.24433243 0.78778043 0.60236144]\n",
      " [0.12448977 0.98189079 0.77429465]\n",
      " [0.82970867 0.43030763 0.0618154 ]]\n",
      "\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T11:50:59.275643Z",
     "start_time": "2025-11-20T11:50:59.271058Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 二、1. 创建形状为 (2, 3) 的矩阵 B 和形状为 (3,) 的向量 v\n",
    "print(\"步骤1：创建矩阵和向量\")\n",
    "B = np.array([[1, 2, 3],\n",
    "              [4, 5, 6]])\n",
    "v = np.array([10, 20, 30])\n",
    "\n",
    "print(\"矩阵 B (形状 {}):\".format(B.shape))\n",
    "print(B)\n",
    "print(\"\\n向量 v (形状 {}):\".format(v.shape))\n",
    "print(v)"
   ],
   "id": "9ad852c6c6f52f50",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "步骤1：创建矩阵和向量\n",
      "矩阵 B (形状 (2, 3)):\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "\n",
      "向量 v (形状 (3,)):\n",
      "[10 20 30]\n"
     ]
    }
   ],
   "execution_count": 24
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T11:53:35.571863Z",
     "start_time": "2025-11-20T11:53:35.567605Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 2. 计算 B + v，观察广播机制\n",
    "print(\"步骤2：计算 B + v\")\n",
    "result1 = B + v\n",
    "print(\"B + v 的结果 (形状 {}):\".format(result1.shape))\n",
    "print(result1)\n",
    "\n",
    "print(\"\\n广播过程解释：\")\n",
    "print(\"B 形状: (2, 3)\")\n",
    "print(\"v 形状: (3,) → 自动补全为 (1, 3)\")\n",
    "print(\"v 被广播为: [[10, 20, 30],\")\n",
    "print(\"             [10, 20, 30]]\")\n",
    "print(\"然后执行逐元素加法\")"
   ],
   "id": "130951916a6561ac",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "步骤2：计算 B + v\n",
      "B + v 的结果 (形状 (2, 3)):\n",
      "[[11 22 33]\n",
      " [14 25 36]]\n",
      "\n",
      "广播过程解释：\n",
      "B 形状: (2, 3)\n",
      "v 形状: (3,) → 自动补全为 (1, 3)\n",
      "v 被广播为: [[10, 20, 30],\n",
      "             [10, 20, 30]]\n",
      "然后执行逐元素加法\n"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:05:30.722110Z",
     "start_time": "2025-11-20T12:05:30.717516Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 3. 将 B 转置后与 v 相加\n",
    "print(\"步骤3：计算 B.T + v\")\n",
    "B_transposed = B.T\n",
    "print(\"B 转置后的形状: {}\".format(B_transposed.shape))\n",
    "print(\"B 转置:\")\n",
    "print(B_transposed)\n",
    "\n",
    "# 需要将v变为列向量才能广播\n",
    "v_column = v.reshape(3, 1)\n",
    "result2 = B_transposed + v_column\n",
    "print(\"\\nB.T + v_column 的结果 (形状 {}):\".format(result2.shape))\n",
    "print(result2)\n",
    "\n",
    "print(\"\\n广播过程解释：\")\n",
    "print(\"B.T 形状: (3, 2)\")\n",
    "print(\"v_column 形状: (3, 1)\")\n",
    "print(\"v_column 被广播为: [[10, 10],\")\n",
    "print(\"                   [20, 20],\")\n",
    "print(\"                   [30, 30]]\")\n",
    "print(\"然后执行逐元素加法\")"
   ],
   "id": "b4b778ff8877996",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "步骤3：计算 B.T + v\n",
      "B 转置后的形状: (3, 2)\n",
      "B 转置:\n",
      "[[1 4]\n",
      " [2 5]\n",
      " [3 6]]\n",
      "\n",
      "B.T + v_column 的结果 (形状 (3, 2)):\n",
      "[[11 14]\n",
      " [22 25]\n",
      " [33 36]]\n",
      "\n",
      "广播过程解释：\n",
      "B.T 形状: (3, 2)\n",
      "v_column 形状: (3, 1)\n",
      "v_column 被广播为: [[10, 10],\n",
      "                   [20, 20],\n",
      "                   [30, 30]]\n",
      "然后执行逐元素加法\n"
     ]
    }
   ],
   "execution_count": 28
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:08:36.343986Z",
     "start_time": "2025-11-20T12:08:36.335423Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 三、1. 创建一个可逆的 3x3 矩阵 C\n",
    "print(\"步骤1：创建可逆矩阵 C\")\n",
    "C = np.array([[1, 2, 3],\n",
    "              [0, 1, 4],\n",
    "              [5, 6, 0]])\n",
    "print(\"矩阵 C:\")\n",
    "print(C)\n",
    "\n",
    "# 检查矩阵是否可逆（行列式不为0）\n",
    "det_C = np.linalg.det(C)\n",
    "print(f\"\\n矩阵 C 的行列式: {det_C:.6f}\")\n",
    "print(\"行列式不为0，矩阵可逆\")\n"
   ],
   "id": "660b8adfe99bad79",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "步骤1：创建可逆矩阵 C\n",
      "矩阵 C:\n",
      "[[1 2 3]\n",
      " [0 1 4]\n",
      " [5 6 0]]\n",
      "\n",
      "矩阵 C 的行列式: 1.000000\n",
      "行列式不为0，矩阵可逆\n"
     ]
    }
   ],
   "execution_count": 30
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:10:55.139313Z",
     "start_time": "2025-11-20T12:10:55.129737Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 2. 计算 C 的逆矩阵 C_inv\n",
    "print(\"步骤2：计算逆矩阵\")\n",
    "C_inv = np.linalg.inv(C)\n",
    "print(\"逆矩阵 C_inv:\")\n",
    "print(C_inv)\n"
   ],
   "id": "d050017253db877",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "步骤2：计算逆矩阵\n",
      "逆矩阵 C_inv:\n",
      "[[-24.  18.   5.]\n",
      " [ 20. -15.  -4.]\n",
      " [ -5.   4.   1.]]\n"
     ]
    }
   ],
   "execution_count": 31
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:12:51.036993Z",
     "start_time": "2025-11-20T12:12:51.032948Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 3. 验证 C @ C_inv 是否接近单位矩阵\n",
    "print(\"步骤3：验证逆矩阵\")\n",
    "product = C @ C_inv\n",
    "print(\"C @ C_inv:\")\n",
    "print(product)\n",
    "\n",
    "# 检查是否接近单位矩阵\n",
    "identity = np.eye(3)\n",
    "difference = np.abs(product - identity)\n",
    "max_error = np.max(difference)\n",
    "print(f\"\\n与单位矩阵的最大误差: {max_error:.10f}\")\n",
    "print(\"由于浮点计算误差，结果非常接近单位矩阵\")"
   ],
   "id": "ee024f47e3eb611c",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "步骤3：验证逆矩阵\n",
      "C @ C_inv:\n",
      "[[ 1.00000000e+00 -3.55271368e-15  0.00000000e+00]\n",
      " [ 0.00000000e+00  1.00000000e+00  0.00000000e+00]\n",
      " [ 0.00000000e+00  0.00000000e+00  1.00000000e+00]]\n",
      "\n",
      "与单位矩阵的最大误差: 0.0000000000\n",
      "由于浮点计算误差，结果非常接近单位矩阵\n"
     ]
    }
   ],
   "execution_count": 32
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:13:45.235777Z",
     "start_time": "2025-11-20T12:13:45.227883Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 4. 解线性方程组 C @ x = b\n",
    "print(\"步骤4：解线性方程组\")\n",
    "b = np.array([1, 2, 3])\n",
    "print(f\"方程组的右边向量 b: {b}\")\n",
    "\n",
    "# 使用 solve 方法解方程\n",
    "x = np.linalg.solve(C, b)\n",
    "print(f\"\\n解向量 x: {x}\")\n",
    "\n",
    "# 验证解的正确性\n",
    "verification = C @ x\n",
    "print(f\"\\n验证 C @ x = {verification}\")\n",
    "print(f\"与原始 b 向量的误差: {np.abs(verification - b)}\")\n",
    "\n",
    "# 使用逆矩阵的方法求解（对比）\n",
    "print(\"\\n\" + \"=\"*50)\n",
    "print(\"对比：使用逆矩阵求解\")\n",
    "x_inv_method = C_inv @ b\n",
    "print(f\"使用逆矩阵求解的 x: {x_inv_method}\")\n",
    "print(f\"两种方法的差异: {np.abs(x - x_inv_method)}\")"
   ],
   "id": "c199956031c0e7e6",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "步骤4：解线性方程组\n",
      "方程组的右边向量 b: [1 2 3]\n",
      "\n",
      "解向量 x: [ 27. -22.   6.]\n",
      "\n",
      "验证 C @ x = [1. 2. 3.]\n",
      "与原始 b 向量的误差: [7.10542736e-15 0.00000000e+00 0.00000000e+00]\n",
      "\n",
      "==================================================\n",
      "对比：使用逆矩阵求解\n",
      "使用逆矩阵求解的 x: [ 27. -22.   6.]\n",
      "两种方法的差异: [3.55271368e-15 0.00000000e+00 0.00000000e+00]\n"
     ]
    }
   ],
   "execution_count": 33
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:25:01.784209Z",
     "start_time": "2025-11-20T12:25:01.780080Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 1. 手动计算导数\n",
    "print(\"步骤1：手动计算导数\")\n",
    "print(\"原函数: f(x) = x² + 3x - 5\")\n",
    "print(\"使用幂法则求导:\")\n",
    "print(\"f'(x) = 2x + 3\")\n",
    "\n",
    "# 定义原函数和导函数\n",
    "def f(x):\n",
    "    return x**2 + 3*x - 5\n",
    "\n",
    "def f_prime(x):\n",
    "    return 2*x + 3"
   ],
   "id": "dd6d0d15e1379909",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "步骤1：手动计算导数\n",
      "原函数: f(x) = x² + 3x - 5\n",
      "使用幂法则求导:\n",
      "f'(x) = 2x + 3\n"
     ]
    }
   ],
   "execution_count": 38
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:19:53.666105Z",
     "start_time": "2025-11-20T12:19:53.662580Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 2. 使用 numpy 生成 x 取值范围 (-10, 10) 的数组\n",
    "print(\"\\n步骤2：生成 x 值数组\")\n",
    "x = np.linspace(-10, 10, 1000)  # 从-10到10生成1000个点\n",
    "print(f\"x 数组形状: {x.shape}\")\n",
    "print(f\"x 范围: [{x.min():.1f}, {x.max():.1f}]\")\n",
    "print(f\"前5个 x 值: {x[:5]}\")\n"
   ],
   "id": "943c1e9cc316f281",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "步骤2：生成 x 值数组\n",
      "x 数组形状: (1000,)\n",
      "x 范围: [-10.0, 10.0]\n",
      "前5个 x 值: [-10.          -9.97997998  -9.95995996  -9.93993994  -9.91991992]\n"
     ]
    }
   ],
   "execution_count": 35
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:20:33.183376Z",
     "start_time": "2025-11-20T12:20:33.179638Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 3. 分别计算原函数值和导数值\n",
    "print(\"\\n步骤3：计算函数值\")\n",
    "y_original = f(x)\n",
    "y_derivative = f_prime(x)\n",
    "\n",
    "print(f\"原函数值范围: [{y_original.min():.2f}, {y_original.max():.2f}]\")\n",
    "print(f\"导数值范围: [{y_derivative.min():.2f}, {y_derivative.max():.2f}]\")\n",
    "\n",
    "# 找到一些关键点\n",
    "zero_derivative = -1.5  # f'(x) = 0 的解\n",
    "min_point = (zero_derivative, f(zero_derivative))\n",
    "\n",
    "print(f\"\\n关键点分析:\")\n",
    "print(f\"导数为零的点: x = {zero_derivative}\")\n",
    "print(f\"函数最小值: f({zero_derivative}) = {min_point[1]:.2f}\")\n"
   ],
   "id": "d8b4089b25b43aca",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "步骤3：计算函数值\n",
      "原函数值范围: [-7.25, 125.00]\n",
      "导数值范围: [-17.00, 23.00]\n",
      "\n",
      "关键点分析:\n",
      "导数为零的点: x = -1.5\n",
      "函数最小值: f(-1.5) = -7.25\n"
     ]
    }
   ],
   "execution_count": 36
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:29:53.258143Z",
     "start_time": "2025-11-20T12:29:52.920011Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 4. 在同一坐标系中绘制图像\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 设置字体\n",
    "plt.rcParams['font.sans-serif'] = ['DejaVu Sans']  # 使用支持数学符号的字体\n",
    "plt.rcParams['axes.unicode_minus'] = False\n",
    "\n",
    "print(\"\\n步骤4：绘制函数图像\")\n",
    "\n",
    "# 创建图形和子图\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))\n",
    "\n",
    "# 绘制原函数\n",
    "ax1.plot(x, y_original, 'b-', linewidth=2, label='f(x) = x^2 + 3x - 5')\n",
    "ax1.axhline(y=0, color='k', linestyle='-', alpha=0.3)\n",
    "ax1.axvline(x=0, color='k', linestyle='-', alpha=0.3)\n",
    "ax1.plot(min_point[0], min_point[1], 'ro', markersize=8,\n",
    "         label=f'Minimum ({min_point[0]:.1f}, {min_point[1]:.2f})')\n",
    "ax1.grid(True, alpha=0.3)\n",
    "ax1.set_xlabel('x')\n",
    "ax1.set_ylabel('f(x)')\n",
    "ax1.set_title('Function: f(x) = x^2 + 3x - 5')\n",
    "ax1.legend()\n",
    "ax1.set_xlim(-10, 10)\n",
    "ax1.set_ylim(-30, 100)\n",
    "\n",
    "# 绘制导函数\n",
    "ax2.plot(x, y_derivative, 'r-', linewidth=2, label=\"f'(x) = 2x + 3\")\n",
    "ax2.axhline(y=0, color='k', linestyle='-', alpha=0.3)\n",
    "ax2.axvline(x=0, color='k', linestyle='-', alpha=0.3)\n",
    "ax2.axvline(x=zero_derivative, color='g', linestyle='--', alpha=0.7,\n",
    "            label=f'Zero derivative at x={zero_derivative}')\n",
    "ax2.grid(True, alpha=0.3)\n",
    "ax2.set_xlabel('x')\n",
    "ax2.set_ylabel(\"f'(x)\")\n",
    "ax2.set_title(\"Derivative: f'(x) = 2x + 3\")\n",
    "ax2.legend()\n",
    "ax2.set_xlim(-10, 10)\n",
    "ax2.set_ylim(-25, 25)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# 在同一坐标系中比较两个函数\n",
    "print(\"\\n在同一坐标系中比较函数和导数\")\n",
    "plt.figure(figsize=(12, 6))\n",
    "\n",
    "plt.plot(x, y_original, 'b-', linewidth=2, label='f(x) = x^2 + 3x - 5')\n",
    "plt.plot(x, y_derivative, 'r--', linewidth=2, label=\"f'(x) = 2x + 3\")\n",
    "plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)\n",
    "plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)\n",
    "plt.axvline(x=zero_derivative, color='g', linestyle=':', alpha=0.7,\n",
    "            label=f'Critical point x={zero_derivative}')\n",
    "\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Function and its Derivative')\n",
    "plt.legend()\n",
    "plt.xlim(-10, 10)\n",
    "plt.ylim(-25, 100)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# 数值分析结果\n",
    "print(\"\\n数值分析结果:\")\n",
    "print(f\"导数零点: x = {zero_derivative}\")\n",
    "print(f\"函数最小值: f({zero_derivative}) = {min_point[1]:.2f}\")\n",
    "\n",
    "# 计算函数零点\n",
    "roots = np.roots([1, 3, -5])\n",
    "print(f\"函数零点:\")\n",
    "print(f\"  x1 = {roots[0]:.4f}\")\n",
    "print(f\"  x2 = {roots[1]:.4f}\")\n",
    "\n",
    "print(f\"\\n函数特性:\")\n",
    "print(f\"1. 导数: f'(x) = 2x + 3\")\n",
    "print(f\"2. 临界点: x = {zero_derivative}\")\n",
    "print(f\"3. 函数行为:\")\n",
    "print(f\"   - 当 x < {zero_derivative}: f'(x) < 0, 函数递减\")\n",
    "print(f\"   - 当 x > {zero_derivative}: f'(x) > 0, 函数递增\")\n",
    "print(f\"4. 顶点(最小值点): ({zero_derivative}, {min_point[1]:.2f})\")\n",
    "\n",
    "# 验证导数计算\n",
    "print(f\"\\n导数验证:\")\n",
    "test_x = 2\n",
    "print(f\"在 x = {test_x} 处:\")\n",
    "print(f\"  函数值 f({test_x}) = {f(test_x):.2f}\")\n",
    "print(f\"  导数值 f'({test_x}) = {f_prime(test_x):.2f}\")\n",
    "print(f\"  数值导数 ≈ {np.gradient(y_original, x)[np.argmin(np.abs(x-test_x))]:.2f}\")"
   ],
   "id": "5865a667854951e1",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "步骤4：绘制函数图像\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x1000 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "在同一坐标系中比较函数和导数\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "数值分析结果:\n",
      "导数零点: x = -1.5\n",
      "函数最小值: f(-1.5) = -7.25\n",
      "函数零点:\n",
      "  x1 = -4.1926\n",
      "  x2 = 1.1926\n",
      "\n",
      "函数特性:\n",
      "1. 导数: f'(x) = 2x + 3\n",
      "2. 临界点: x = -1.5\n",
      "3. 函数行为:\n",
      "   - 当 x < -1.5: f'(x) < 0, 函数递减\n",
      "   - 当 x > -1.5: f'(x) > 0, 函数递增\n",
      "4. 顶点(最小值点): (-1.5, -7.25)\n",
      "\n",
      "导数验证:\n",
      "在 x = 2 处:\n",
      "  函数值 f(2) = 5.00\n",
      "  导数值 f'(2) = 7.00\n",
      "  数值导数 ≈ 6.98\n"
     ]
    }
   ],
   "execution_count": 41
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:32:10.110696Z",
     "start_time": "2025-11-20T12:32:10.106422Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 五、1. 计算函数的梯度\n",
    "print(\"步骤1：计算函数的梯度\")\n",
    "print(\"函数: f(x, y) = x^2 - y^2\")\n",
    "\n",
    "# 定义函数\n",
    "def f(x, y):\n",
    "    return x**2 - y**2\n",
    "\n",
    "# 计算偏导数\n",
    "def df_dx(x, y):\n",
    "    \"\"\"对x的偏导数\"\"\"\n",
    "    return 2*x\n",
    "\n",
    "def df_dy(x, y):\n",
    "    \"\"\"对y的偏导数\"\"\"\n",
    "    return -2*y\n",
    "\n",
    "def gradient(x, y):\n",
    "    \"\"\"梯度向量\"\"\"\n",
    "    return np.array([df_dx(x, y), df_dy(x, y)])\n",
    "\n",
    "print(\"梯度: ∇f(x, y) = (∂f/∂x, ∂f/∂y) = (2x, -2y)\")"
   ],
   "id": "af53ef5036feea39",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "步骤1：计算函数的梯度\n",
      "函数: f(x, y) = x^2 - y^2\n",
      "梯度: ∇f(x, y) = (∂f/∂x, ∂f/∂y) = (2x, -2y)\n"
     ]
    }
   ],
   "execution_count": 43
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:33:11.978788Z",
     "start_time": "2025-11-20T12:33:11.974265Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 2. 在 x∈(-2, 2) 和 y∈(-2, 2) 范围内创建网格\n",
    "print(\"\\n步骤2：创建网格\")\n",
    "x = np.linspace(-2, 2, 50)\n",
    "y = np.linspace(-2, 2, 50)\n",
    "X, Y = np.meshgrid(x, y)\n",
    "Z = f(X, Y)\n",
    "\n",
    "print(f\"X 网格形状: {X.shape}\")\n",
    "print(f\"Y 网格形状: {Y.shape}\")\n",
    "print(f\"Z 值形状: {Z.shape}\")\n",
    "print(f\"Z 值范围: [{Z.min():.2f}, {Z.max():.2f}]\")\n"
   ],
   "id": "e37b785971e7e596",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "步骤2：创建网格\n",
      "X 网格形状: (50, 50)\n",
      "Y 网格形状: (50, 50)\n",
      "Z 值形状: (50, 50)\n",
      "Z 值范围: [-4.00, 4.00]\n"
     ]
    }
   ],
   "execution_count": 44
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:37:45.529356Z",
     "start_time": "2025-11-20T12:37:45.360195Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def sigmoid(x):\n",
    "    \"\"\"\n",
    "    Sigmoid 激活函数\n",
    "    公式: sigmoid(x) = 1 / (1 + exp(-x))\n",
    "\n",
    "    参数:\n",
    "    x: 输入值（可以是标量、向量或矩阵）\n",
    "\n",
    "    返回:\n",
    "    sigmoid 变换后的值\n",
    "    \"\"\"\n",
    "    return 1 / (1 + np.exp(-x))\n",
    "\n",
    "def sigmoid_derivative(x):\n",
    "    \"\"\"\n",
    "    Sigmoid 函数的导数\n",
    "    公式: sigmoid'(x) = sigmoid(x) * (1 - sigmoid(x))\n",
    "    \"\"\"\n",
    "    s = sigmoid(x)\n",
    "    return s * (1 - s)\n",
    "\n",
    "# 测试 sigmoid 函数\n",
    "print(\"Sigmoid 函数测试:\")\n",
    "x_test = np.array([-2, -1, 0, 1, 2])\n",
    "print(f\"输入: {x_test}\")\n",
    "print(f\"输出: {sigmoid(x_test)}\")\n",
    "print(f\"导数: {sigmoid_derivative(x_test)}\")\n",
    "\n",
    "# 绘制 sigmoid 函数图像\n",
    "plt.figure(figsize=(12, 4))\n",
    "\n",
    "x = np.linspace(-6, 6, 100)\n",
    "y_sigmoid = sigmoid(x)\n",
    "y_derivative = sigmoid_derivative(x)\n",
    "\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(x, y_sigmoid, 'b-', linewidth=2, label='sigmoid(x)')\n",
    "plt.axhline(y=0.5, color='r', linestyle='--', alpha=0.5, label='y=0.5')\n",
    "plt.axvline(x=0, color='r', linestyle='--', alpha=0.5, label='x=0')\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('sigmoid(x)')\n",
    "plt.title('Sigmoid Function')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(x, y_derivative, 'g-', linewidth=2, label=\"sigmoid'(x)\")\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel(\"sigmoid'(x)\")\n",
    "plt.title('Sigmoid Derivative')\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "id": "96c689c256138752",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sigmoid 函数测试:\n",
      "输入: [-2 -1  0  1  2]\n",
      "输出: [0.11920292 0.26894142 0.5        0.73105858 0.88079708]\n",
      "导数: [0.10499359 0.19661193 0.25       0.19661193 0.10499359]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 46
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-20T12:38:05.277434Z",
     "start_time": "2025-11-20T12:38:05.270008Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def softmax(x):\n",
    "    \"\"\"\n",
    "    Softmax 函数\n",
    "    将输入向量转换为概率分布\n",
    "    公式: softmax(x_i) = exp(x_i) / sum(exp(x_j))\n",
    "\n",
    "    参数:\n",
    "    x: 输入向量或矩阵\n",
    "\n",
    "    返回:\n",
    "    softmax 变换后的概率分布\n",
    "    \"\"\"\n",
    "    # 数值稳定性处理：减去最大值防止指数溢出\n",
    "    x_shifted = x - np.max(x, axis=-1, keepdims=True)\n",
    "    exp_x = np.exp(x_shifted)\n",
    "    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)\n",
    "\n",
    "def softmax_derivative(s):\n",
    "    \"\"\"\n",
    "    Softmax 函数的导数（Jacobian 矩阵）\n",
    "    参数 s 应该是 softmax 的输出\n",
    "\n",
    "    对于 softmax 输出 s，导数矩阵为:\n",
    "    ∂s_i/∂x_j = s_i * (δ_ij - s_j)\n",
    "    其中 δ_ij 是 Kronecker delta\n",
    "    \"\"\"\n",
    "    # 对于向量输入，返回 Jacobian 矩阵\n",
    "    return np.diag(s) - np.outer(s, s)\n",
    "\n",
    "# 测试 softmax 函数\n",
    "print(\"\\nSoftmax 函数测试:\")\n",
    "\n",
    "# 测试 1: 简单向量\n",
    "x_vector = np.array([1.0, 2.0, 3.0])\n",
    "softmax_vector = softmax(x_vector)\n",
    "print(f\"输入向量: {x_vector}\")\n",
    "print(f\"Softmax 输出: {softmax_vector}\")\n",
    "print(f\"输出总和: {np.sum(softmax_vector):.6f}\")  # 应该为 1\n",
    "\n",
    "# 测试 2: 批量数据（矩阵）\n",
    "x_batch = np.array([[1, 2, 3],\n",
    "                    [1, 1, 1],\n",
    "                    [0, 0, 1]])\n",
    "softmax_batch = softmax(x_batch)\n",
    "print(f\"\\n批量输入:\\n{x_batch}\")\n",
    "print(f\"批量 Softmax:\\n{softmax_batch}\")\n",
    "print(f\"每行总和: {np.sum(softmax_batch, axis=1)}\")\n",
    "\n",
    "# 测试 3: 数值稳定性测试（大数值）\n",
    "x_large = np.array([1000, 1001, 1002])\n",
    "softmax_large = softmax(x_large)\n",
    "print(f\"\\n大数值输入: {x_large}\")\n",
    "print(f\"Softmax 输出: {softmax_large}\")\n",
    "print(f\"输出总和: {np.sum(softmax_large):.6f}\")"
   ],
   "id": "98d52dc8a0e5bf7c",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Softmax 函数测试:\n",
      "输入向量: [1. 2. 3.]\n",
      "Softmax 输出: [0.09003057 0.24472847 0.66524096]\n",
      "输出总和: 1.000000\n",
      "\n",
      "批量输入:\n",
      "[[1 2 3]\n",
      " [1 1 1]\n",
      " [0 0 1]]\n",
      "批量 Softmax:\n",
      "[[0.09003057 0.24472847 0.66524096]\n",
      " [0.33333333 0.33333333 0.33333333]\n",
      " [0.21194156 0.21194156 0.57611688]]\n",
      "每行总和: [1. 1. 1.]\n",
      "\n",
      "大数值输入: [1000 1001 1002]\n",
      "Softmax 输出: [0.09003057 0.24472847 0.66524096]\n",
      "输出总和: 1.000000\n"
     ]
    }
   ],
   "execution_count": 48
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "",
   "id": "9bf99b63459b40ed"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
